
//滑滚位置
var scrollSmoothTo = function (dom, position, endback) {
    if (dom.scrollHeight <= dom.clientHeight) {
        return;
    }
    window.scrollStop=false;
    var timeIndex;
    if (!window.requestAnimationFrame) {
        window.requestAnimationFrame = function (callback, element) {
            return setTimeout(callback, 17);
        };
    }
    // 当前滚动高度
    var scrollTop = !isNaN(parseFloat(dom.scrollY)) ? dom.scrollY : dom.scrollTop;
    // 滚动step方法
    var step = function () {
        // 距离目标滚动距离
        var distance = position - scrollTop;
        // 目标滚动位置
        scrollTop = scrollTop + distance / 6;
        if (Math.abs(distance) < 1) {
            dom.scrollTo(0, position);
            endback && endback();
        } else if(!window.scrollStop) {
            dom.scrollTo(0, scrollTop);
            requestAnimationFrame(step);
        }
    };
    step();
};


/**
 * 横向匀速滚动
 * @param {目标元素} _element 
 * @param {滚动位置} _targetPosition 
 * @param {动画时间} _duration 
 * @param {结束回调} _callback 
 * var scroll = new scrollToTarget(...);
 */
function scrollToTarget(_element, _targetPosition, _duration, _callback) {
    var element = _element;
    var callback = _callback || function () { };
    // 获取当前滚动位置
    var startPosition = element.scrollLeft;
    // 计算需要滚动的距离
    var distance = _targetPosition - startPosition;
    var duration = _duration>=0 ? _duration : 700;
    // 添加一个状态变量，用于跟踪动画是否应该停止
    var shouldAnimate = true;
    // 设置动画开始时间
    var startTime = performance.now();
    // 动画函数
    function animation() {
        if (!shouldAnimate) {
            // 如果shouldAnimate为false，停止动画
            return;
        }
        let currentTime = performance.now();
        // 如果没有开始时间，则设置开始时间为当前时间
        if (!startTime) startTime = currentTime;
        // 计算已过去的时间
        let timeElapsed = currentTime - startTime;
        // 计算当前滚动位置
        let run = ease(timeElapsed, startPosition, distance, duration);
        // 设置元素的滚动位置
        element.scrollLeft = run;
        // 如果动画没有结束，继续请求动画帧
        if (timeElapsed < duration) {
            requestAnimationFrame(animation);
        } else {
            shouldAnimate = false;
            // 动画结束，执行回调函数
            if (callback && typeof callback === 'function') {
                callback();
            }
        }
    }
    // 请求动画帧
    animation();

    // 缓动函数，用于计算动画过程中的位置
    function ease(t, b, c, d) {
        t /= d / 2;
        if (t < 1) return c / 2 * t * t + b;
        t--;
        return -c / 2 * (t * (t - 2) - 1) + b;
    }
    // 缓动函数，由快至慢的动画效果
    function easeOutCubic(t, b, c, d) {
        t /= d;
        t--;
        return c * (t * t * t + 1) + b;
    }
    // 返回一个对象，包含停止动画的方法
    return {
        stop: function () {
            shouldAnimate = false;
        },
        start(_position, _duration, _callback) {
            callback = _callback || callback;
            // 获取当前滚动位置
            startPosition = element.scrollLeft;
            // 计算需要滚动的距离
            distance = _position - startPosition;
            duration = _duration>=0 ? _duration : duration;
            startTime = performance.now();
            if(!shouldAnimate){
                shouldAnimate = true;
                animation();
            }else{
                shouldAnimate = true;
            }
        }
    };
}